package config

import (
	"fmt"
	"log"
	"os"
	"path/filepath"

	"github.com/spf13/viper"
)

// Config 应用程序配置结构体
type Config struct {
	Server     ServerConfig     `mapstructure:"server"`
	BGEService BGEServiceConfig `mapstructure:"bge_service"`
	VectorDB   VectorDBConfig   `mapstructure:"vector_db"`
	FileIndex  FileIndexConfig  `mapstructure:"file_index"`
	Monitoring MonitoringConfig `mapstructure:"monitoring"`
	MCP        MCPConfig        `mapstructure:"mcp"`
}

// ServerConfig 服务器配置
type ServerConfig struct {
	Host string `mapstructure:"host"`
	Port int    `mapstructure:"port"`
	Mode string `mapstructure:"mode"` // debug, release
}

// BGEServiceConfig BGE服务配置
type BGEServiceConfig struct {
	Host    string `mapstructure:"host"`
	Port    int    `mapstructure:"port"`
	APIKey  string `mapstructure:"api_key"`
	Timeout int    `mapstructure:"timeout"` // 超时时间（秒）
}

// VectorDBConfig 向量数据库配置
type VectorDBConfig struct {
	Host     string `mapstructure:"host"`
	Port     int    `mapstructure:"port"`
	GRPCPort int    `mapstructure:"grpc_port"`
	APIKey   string `mapstructure:"api_key"`
	UseTLS   bool   `mapstructure:"use_tls"`
	Timeout  int    `mapstructure:"timeout"` // 超时时间（秒）
}

// FileIndexConfig 文件索引配置
type FileIndexConfig struct {
	SupportedExtensions []string `mapstructure:"supported_extensions"`
	ChunkSize           int      `mapstructure:"chunk_size"`           // 分块大小（字符数）
	ChunkOverlap        int      `mapstructure:"chunk_overlap"`        // 分块重叠大小（字符数）
	MaxFileSize         int64    `mapstructure:"max_file_size"`        // 最大文件大小（字节）
	ExcludeDirs         []string `mapstructure:"exclude_dirs"`         // 排除的目录
	IndexDirectories    []string `mapstructure:"index_directories"`    // 索引目录列表
	EnableSummary       bool     `mapstructure:"enable_summary"`       // 是否启用摘要提取
	SummaryLength       int      `mapstructure:"summary_length"`       // 摘要长度
	SemanticChunking    bool     `mapstructure:"semantic_chunking"`    // 是否启用语义分块
	MinChunkSize        int      `mapstructure:"min_chunk_size"`       // 最小分块大小
	MaxChunkSize        int      `mapstructure:"max_chunk_size"`       // 最大分块大小
	AutoIndexNewFiles   bool     `mapstructure:"auto_index_new_files"` // 自动索引新文件
}

// MonitoringConfig 监控配置
type MonitoringConfig struct {
	EnableAutoScan bool `mapstructure:"enable_auto_scan"`  // 启用自动扫描
	ScanInterval   int  `mapstructure:"scan_interval"`     // 扫描间隔（秒）
	EnableRealTime bool `mapstructure:"enable_real_time"`  // 启用实时监控
}

// MCPConfig MCP服务器配置
type MCPConfig struct {
	APIKey string `mapstructure:"api_key"` // MCP服务器访问密钥
	Port   int    `mapstructure:"port"`    // MCP服务器端口
}

// LoadConfig 加载配置文件
func LoadConfig() (*Config, error) {
	return LoadConfigWithPath("")
}

// LoadConfigWithPath 从指定路径加载配置文件
func LoadConfigWithPath(configPath string) (*Config, error) {
	v := viper.New()
	
	// 如果指定了配置文件路径，则使用该路径
	if configPath != "" {
		// 获取文件扩展名以确定配置类型
		ext := filepath.Ext(configPath)
		if ext == "" {
			ext = ".yaml" // 默认为YAML格式
		}
		
		// 设置配置文件名和类型
		v.SetConfigFile(configPath)
		v.SetConfigType(ext[1:]) // 去掉点号
	} else {
		// 使用默认配置文件路径
		v.SetConfigName("config")
		v.SetConfigType("yaml")
		v.AddConfigPath(".")
		v.AddConfigPath("./config")
		v.AddConfigPath("/etc/go-file-perception-model")
	}

	// 设置默认值
	setDefaultsForViper(v)

	// 从环境变量读取
	v.AutomaticEnv()

	// 读取配置文件
	if err := v.ReadInConfig(); err != nil {
		// 如果配置文件不存在，尝试创建默认配置文件
		if _, ok := err.(viper.ConfigFileNotFoundError); ok {
			log.Printf("Config file not found, creating default config...")
			if err := createDefaultConfig(); err != nil {
				return nil, fmt.Errorf("failed to create default config: %w", err)
			}
			// 再次尝试读取配置文件
			if err := v.ReadInConfig(); err != nil {
				return nil, fmt.Errorf("failed to read config after creating default: %w", err)
			}
		} else {
			return nil, fmt.Errorf("failed to read config: %w", err)
		}
	}

	var config Config
	if err := v.Unmarshal(&config); err != nil {
		return nil, fmt.Errorf("failed to unmarshal config: %w", err)
	}

	// 处理配置中的引号路径
	processConfigPaths(&config)

	return &config, nil
}

// setDefaultsForViper 为指定的viper实例设置默认配置值
func setDefaultsForViper(v *viper.Viper) {
	// 服务器默认配置
	v.SetDefault("server.host", "0.0.0.0")
	v.SetDefault("server.port", 8080)
	v.SetDefault("server.mode", "debug")

	// BGE服务默认配置
	v.SetDefault("bge_service.host", "localhost")
	v.SetDefault("bge_service.port", 8000)
	v.SetDefault("bge_service.api_key", "bge-service-secret-key-2023")
	v.SetDefault("bge_service.timeout", 30)

	// 向量数据库默认配置
	v.SetDefault("vector_db.host", "localhost")
	v.SetDefault("vector_db.port", 6333)
	v.SetDefault("vector_db.grpc_port", 6334)
	v.SetDefault("vector_db.use_tls", false)
	v.SetDefault("vector_db.timeout", 30)

	// 文件索引默认配置
	v.SetDefault("file_index.supported_extensions", []string{".md", ".txt", ".c", ".cpp", ".h", ".hpp", ".js", ".ts", ".go", ".py", ".java"})
	v.SetDefault("file_index.chunk_size", 1000)
	v.SetDefault("file_index.chunk_overlap", 200)
	v.SetDefault("file_index.max_file_size", 10485760) // 10MB
	v.SetDefault("file_index.exclude_dirs", []string{".git", ".idea", ".vscode", "node_modules"})
	v.SetDefault("file_index.index_directories", []string{"./data"})
	v.SetDefault("file_index.enable_summary", false)
	v.SetDefault("file_index.summary_length", 200)
	v.SetDefault("file_index.semantic_chunking", false)
	v.SetDefault("file_index.min_chunk_size", 100)
	v.SetDefault("file_index.max_chunk_size", 2000)
	v.SetDefault("file_index.auto_index_new_files", true)

	// 监控默认配置
	v.SetDefault("monitoring.enable_auto_scan", true)
	v.SetDefault("monitoring.scan_interval", 300) // 5分钟
	v.SetDefault("monitoring.enable_real_time", true)

	// MCP默认配置
	v.SetDefault("mcp.api_key", "mcp-server-secret-key-2025")
	v.SetDefault("mcp.port", 8081)
}

// setDefaults 设置默认配置值
func setDefaults() {
	setDefaultsForViper(viper.GetViper())
}

// processConfigPaths 处理配置中的引号路径
func processConfigPaths(config *Config) {
	// 处理文件索引目录
	for i, dir := range config.FileIndex.IndexDirectories {
		if len(dir) > 1 && dir[0] == '"' && dir[len(dir)-1] == '"' {
			config.FileIndex.IndexDirectories[i] = dir[1 : len(dir)-1]
		}
	}
	
	// 处理排除目录
	for i, dir := range config.FileIndex.ExcludeDirs {
		if len(dir) > 1 && dir[0] == '"' && dir[len(dir)-1] == '"' {
			config.FileIndex.ExcludeDirs[i] = dir[1 : len(dir)-1]
		}
	}
}

// Save 保存配置到文件（只更新file_index部分，保留其他配置）
func (c *FileIndexConfig) Save() error {
	// 加载现有的完整配置
	existingConfig, err := LoadConfig()
	if err != nil {
		// 如果加载失败，创建新的配置
		log.Printf("Warning: Failed to load existing config, creating new one: %v", err)
		return c.saveAsNewConfig()
	}

	// 更新file_index部分
	existingConfig.FileIndex = *c

	// 保存完整配置
	return saveCompleteConfig(existingConfig)
}

// saveAsNewConfig 保存为新配置文件（当无法加载现有配置时使用）
func (c *FileIndexConfig) saveAsNewConfig() error {
	// 创建包含所有默认值的完整配置
	v := viper.New()
	setDefaultsForViper(v)

	// 更新file_index部分
	v.Set("file_index.supported_extensions", c.SupportedExtensions)
	v.Set("file_index.chunk_size", c.ChunkSize)
	v.Set("file_index.chunk_overlap", c.ChunkOverlap)
	v.Set("file_index.max_file_size", c.MaxFileSize)
	v.Set("file_index.exclude_dirs", c.ExcludeDirs)
	v.Set("file_index.index_directories", c.IndexDirectories)
	v.Set("file_index.enable_summary", c.EnableSummary)
	v.Set("file_index.summary_length", c.SummaryLength)
	v.Set("file_index.semantic_chunking", c.SemanticChunking)
	v.Set("file_index.min_chunk_size", c.MinChunkSize)
	v.Set("file_index.max_chunk_size", c.MaxChunkSize)
	v.Set("file_index.auto_index_new_files", c.AutoIndexNewFiles)

	// 确保MCP配置存在
	if !v.IsSet("mcp") {
		v.Set("mcp.api_key", "mcp-server-secret-key-2025")
		v.Set("mcp.port", 8081)
	}

	// 确保config目录存在
	if err := os.MkdirAll("config", 0755); err != nil {
		return fmt.Errorf("failed to create config directory: %w", err)
	}

	// 保存配置文件
	configPath := filepath.Join("config", "config.yaml")
	if err := v.WriteConfigAs(configPath); err != nil {
		return fmt.Errorf("failed to write config file: %w", err)
	}

	return nil
}

// saveCompleteConfig 保存完整配置到文件
func saveCompleteConfig(config *Config) error {
	v := viper.New()

	// 设置所有配置值
	// 服务器配置
	v.Set("server.host", config.Server.Host)
	v.Set("server.port", config.Server.Port)
	v.Set("server.mode", config.Server.Mode)

	// BGE服务配置
	v.Set("bge_service.host", config.BGEService.Host)
	v.Set("bge_service.port", config.BGEService.Port)
	v.Set("bge_service.api_key", config.BGEService.APIKey)
	v.Set("bge_service.timeout", config.BGEService.Timeout)

	// 向量数据库配置
	v.Set("vector_db.host", config.VectorDB.Host)
	v.Set("vector_db.port", config.VectorDB.Port)
	v.Set("vector_db.grpc_port", config.VectorDB.GRPCPort)
	v.Set("vector_db.api_key", config.VectorDB.APIKey)
	v.Set("vector_db.use_tls", config.VectorDB.UseTLS)
	v.Set("vector_db.timeout", config.VectorDB.Timeout)

	// 文件索引配置
	v.Set("file_index.supported_extensions", config.FileIndex.SupportedExtensions)
	v.Set("file_index.chunk_size", config.FileIndex.ChunkSize)
	v.Set("file_index.chunk_overlap", config.FileIndex.ChunkOverlap)
	v.Set("file_index.max_file_size", config.FileIndex.MaxFileSize)
	v.Set("file_index.exclude_dirs", config.FileIndex.ExcludeDirs)
	v.Set("file_index.index_directories", config.FileIndex.IndexDirectories)
	v.Set("file_index.enable_summary", config.FileIndex.EnableSummary)
	v.Set("file_index.summary_length", config.FileIndex.SummaryLength)
	v.Set("file_index.semantic_chunking", config.FileIndex.SemanticChunking)
	v.Set("file_index.min_chunk_size", config.FileIndex.MinChunkSize)
	v.Set("file_index.max_chunk_size", config.FileIndex.MaxChunkSize)
	v.Set("file_index.auto_index_new_files", config.FileIndex.AutoIndexNewFiles)

	// 监控配置
	v.Set("monitoring.enable_auto_scan", config.Monitoring.EnableAutoScan)
	v.Set("monitoring.scan_interval", config.Monitoring.ScanInterval)
	v.Set("monitoring.enable_real_time", config.Monitoring.EnableRealTime)

	// MCP配置
	v.Set("mcp.api_key", config.MCP.APIKey)
	v.Set("mcp.port", config.MCP.Port)

	// 确保config目录存在
	if err := os.MkdirAll("config", 0755); err != nil {
		return fmt.Errorf("failed to create config directory: %w", err)
	}

	// 保存配置文件
	configPath := filepath.Join("config", "config.yaml")
	if err := v.WriteConfigAs(configPath); err != nil {
		return fmt.Errorf("failed to write config file: %w", err)
	}

	log.Printf("Configuration saved successfully to %s", configPath)
	return nil
}

// createDefaultConfig 创建默认配置文件
func createDefaultConfig() error {
	// 确保config目录存在
	if err := os.MkdirAll("config", 0755); err != nil {
		return fmt.Errorf("failed to create config directory: %w", err)
	}

	// 创建默认配置文件
	configPath := filepath.Join("config", "config.yaml")
	file, err := os.Create(configPath)
	if err != nil {
		return fmt.Errorf("failed to create config file: %w", err)
	}
	defer file.Close()

	// 写入默认配置
	defaultConfig := `# Go文件感知国产模型配置文件

# 服务器配置
server:
  host: "0.0.0.0"
  port: 8080
  mode: "debug"  # debug, release

# 嵌入模型配置
# 嵌入模型现在由独立的Python BGE服务管理，不需要在Go程序中配置

# BGE服务配置
bge_service:
  host: "localhost"
  port: 8000
  api_key: "bge-service-secret-key-2023"  # BGE服务API密钥
  timeout: 30  # 超时时间（秒）

# 向量数据库配置
vector_db:
  host: "localhost"
  port: 6333
  grpc_port: 6334  # gRPC端口
  api_key: ""
  use_tls: false
  timeout: 30  # 超时时间（秒）

# 文件索引配置
file_index:
  supported_extensions: [".md", ".txt", ".c", ".cpp", ".h", ".hpp", ".js", ".ts", ".go", ".py", ".java"]
  chunk_size: 1000  # 分块大小（字符数）
  chunk_overlap: 200  # 分块重叠大小（字符数）
  max_file_size: 10485760  # 最大文件大小（字节），10MB
  exclude_dirs: [".git", ".idea", ".vscode", "node_modules"]
  index_directories: ["./data"]  # 索引目录列表
  enable_summary: false  # 是否启用摘要提取
  summary_length: 200  # 摘要长度
  semantic_chunking: false  # 是否启用语义分块
  min_chunk_size: 100  # 最小分块大小
  max_chunk_size: 2000  # 最大分块大小
  auto_index_new_files: true  # 自动索引新文件

# 监控配置
monitoring:
  enable_auto_scan: true
  scan_interval: 300  # 扫描间隔（秒）
  enable_real_time: true

# MCP服务器配置
mcp:
  api_key: "mcp-server-secret-key-2025"  # MCP服务器访问密钥，请修改为您自己的密钥
  port: 8081  # MCP服务器端口
`

	if _, err := file.WriteString(defaultConfig); err != nil {
		return fmt.Errorf("failed to write default config: %w", err)
	}

	return nil
}
